// 应用操作组合式函数

import { ref } from 'vue'
import { Window } from '@tauri-apps/api/window'
import { WebviewWindow } from '@tauri-apps/api/webviewWindow'
import type { MenuAction, ContractInfo } from '@/types/trading'
import { useContractStore } from '@/stores/contractStore'

export function useAppActions(
  openTradingPanelCallback?: (setNumber: number, tradeName?: string) => Promise<void>,
  getCurrentActiveSet?: () => number
) {
  // 搜索窗口引用
  const searchWindow = ref<WebviewWindow | null>(null)

  // 合约状态管理
  const { setCurrentContract, setPanelContract } = useContractStore()

  // 搜索功能 - 创建独立的搜索窗口
  const openSearchDialog = async () => {
    try {

      // 首先检查本地引用的搜索窗口
      if (searchWindow.value) {
        try {
          await searchWindow.value.setFocus()
          await searchWindow.value.unminimize()
          return
        } catch (error) {
          searchWindow.value = null
        }
      }

      // 检查是否有其他合约搜索窗口实例
      try {
        const { getAllWebviewWindows } = await import('@tauri-apps/api/webviewWindow')
        const allWindows = getAllWebviewWindows()

        // 查找现有的合约搜索窗口
        const existingSearchWindow = Array.isArray(allWindows)
          ? allWindows.find(window => window.label && window.label.includes('contract-search'))
          : null

        if (existingSearchWindow) {
          await existingSearchWindow.setFocus()
          await existingSearchWindow.unminimize()
          searchWindow.value = existingSearchWindow
          return
        }
      } catch (error) {
      }

      // 创建新的搜索窗口
      const windowId = `contract-search-${Date.now()}`
      const window = new WebviewWindow(windowId, {
        url: '#/contract-search',
        title: '合约订阅与管理',
        width: 200,
        height: 400,
        resizable: true,
        decorations: false,
        // alwaysOnTop: true,
        center: true,
        skipTaskbar: false,
        visible: true,
        minimizable: true,
        maximizable: false,
        closable: true,
        // focus: true
      })

      // 监听窗口创建成功
      window.once('tauri://created', () => {
        searchWindow.value = window
      })

      // 监听窗口关闭
      window.once('tauri://close-requested', () => {
        searchWindow.value = null
      })

      // 监听窗口销毁
      window.once('tauri://destroyed', () => {
        if (searchWindow.value) {
          searchWindow.value = null
        }
      })

      // 监听窗口创建失败
      window.once('tauri://error', (error) => {
        searchWindow.value = null
      })

    } catch (error) {
    }
  }

  // 处理合约选择
  const handleContractSelected = async (contract: ContractInfo) => {
    try {
      // 打开合约交易面板（面板内部会自动订阅该合约的行情数据）
      await openContractTradingPanel(contract)
    } catch (error) {
    }
  }

  // 打开合约交易面板
  const openContractTradingPanel = async (contract: ContractInfo) => {
    // 获取当前选中的集合编号
    const activeSetNumber = getCurrentActiveSet ? getCurrentActiveSet() : 1
    // 设置当前选中的合约
    setCurrentContract(contract)

    // 使用合约代码作为面板标题
    const tradeName = `${contract.name} (${contract.code})`

    // 调用传入的回调函数打开交易面板，使用当前选中的集合
    if (openTradingPanelCallback) {
      await openTradingPanelCallback(activeSetNumber, tradeName)

      // 为新打开的面板设置合约信息
      const panelId = `trading-panel-${activeSetNumber}-${Date.now()}`
      setPanelContract(panelId, contract)

      console.log(`已为集合${activeSetNumber}打开合约${contract.code}的交易面板`)
    } else {
      console.warn('未提供 openTradingPanelCallback，无法打开交易面板')
    }
  }

  // 同步数据
  const syncData = async () => {
    try {
      // TODO: 实现与服务器同步
      setTimeout(() => {
        console.log('数据同步完成')
      }, 2000)
    } catch (error) {
      console.error('同步数据失败:', error)
    }
  }

  // 检查更新
  const checkForUpdates = async () => {
    try {
      // TODO: 实现版本检查
      setTimeout(() => {
        console.log('当前已是最新版本')
      }, 2000)
    } catch (error) {
      console.error('检查更新失败:', error)
    }
  }

  // 关闭搜索窗口
  const closeSearchWindow = async () => {
    try {
      if (searchWindow.value) {
        await searchWindow.value.close()
        searchWindow.value = null
      }
    } catch (error) {
    }
  }

  // 关闭所有相关窗口（搜索窗口、合约行情窗口等）
  const closeAllRelatedWindows = async () => {
    try {
      // 1. 关闭搜索窗口
      await closeSearchWindow()

      // 2. 获取所有窗口并关闭特定类型的窗口
      const { getAllWebviewWindows } = await import('@tauri-apps/api/webviewWindow')
      const allWindows = getAllWebviewWindows()

      // 检查 allWindows 是否为数组，如果不是则转换为数组
      let windowsArray = []
      if (Array.isArray(allWindows)) {
        windowsArray = allWindows
      } else if (allWindows && typeof allWindows === 'object') {
        // 如果是对象，尝试获取其值
        windowsArray = Object.values(allWindows)
      } else {
        return
      }

      for (const window of windowsArray) {
        try {
          // 确保 window 对象存在且有 label 属性
          if (!window || !window.label) {
            continue
          }

          const label = window.label
          // 关闭所有窗口（包括搜索窗口、合约行情窗口、交易面板），但不关闭主窗口
          if (label.includes('contract-search') ||
            label.includes('trading-panel')) {
            await window.close()
          }
        } catch (error) {
          // 继续关闭其他窗口，不因单个窗口失败而中断
        }
      }

    } catch (error) {
    }
  }

  // 退出应用
  const exitApplication = async (closeAllTradingPanels: () => Promise<void>) => {
    try {
      // 1. 关闭所有相关窗口（搜索窗口、合约行情窗口等）
      await closeAllRelatedWindows()

      // 2. 关闭所有交易面板
      await closeAllTradingPanels()

      // 3. 关闭主窗口
      const mainWindow = Window.getCurrent()
      await mainWindow.close()
    } catch (error) {
    }
  }

  // 配置交易集
  const configureTradingSet = (setNumber: number) => {
    console.log(`配置交易集${setNumber}`)
    // TODO: 实现交易集配置功能
  }

  // 处理菜单操作
  const handleMenuAction = async (
    action: MenuAction,
    callbacks: {
      saveConfiguration: () => Promise<void>
      loadXMLConfiguration: () => Promise<void>
      closeAllTradingPanels: () => Promise<void>
    }
  ) => {
    switch (action) {
      case 'save':
        // 保存配置时先关闭相关窗口
        await closeAllRelatedWindows()
        await callbacks.saveConfiguration()
        break
      case 'load':
        await callbacks.loadXMLConfiguration()
        break
      case 'search':
        await openSearchDialog()
        break
      case 'sync':
        await syncData()
        break
      case 'update':
        await checkForUpdates()
        break
      case 'exit':
        await exitApplication(callbacks.closeAllTradingPanels)
        break
    }
  }

  return {
    searchWindow,
    openSearchDialog,
    closeSearchWindow,
    closeAllRelatedWindows,
    handleContractSelected,
    openContractTradingPanel,
    syncData,
    checkForUpdates,
    exitApplication,
    configureTradingSet,
    handleMenuAction
  }
}
